/**
 * 服务注册配置
 * 将现有的SDK服务注册到依赖注入容器中
 */

import { container, ServiceIdentifiers } from './ServiceContainer';

// 导入现有的管理器和服务
import UserManager from '../../core/manage/UserManager';
import MailManager from '../../core/manage/MailManager';
import SceneManager from '../../core/manage/SceneManager';
import ComponentManage from '../../core/manage/ComponentManage';
import { ClientManage } from '../../core/index';

// 导入现代化服务
import { ModernBagService } from '../../service/ModernBagService';
import { ModernRPGService } from '../../service/ModernRPGService';
import { ModernSignService } from '../../service/ModernSignService';
import { ModernIntentService } from '../../service/ModernIntentService';

// 导入Repository
import { BagRepository } from '../../repository/BagRepository';
import { RPGRepository } from '../../repository/RPGRepository';
import { OptimizedBagRepository } from '../../repository/OptimizedBagRepository';
import { OptimizedRPGRepository } from '../../repository/OptimizedRPGRepository';

// 导入工具
import common from '../../core/tool/common';
import { Icard } from '../../core/tool/Icard';
import dbInstance from '../../core/tool/db';

// 导入缓存
import { globalCache } from '../cache/SimpleCache';
import { RepositoryHelper } from '../repository/RepositoryHelper';

/**
 * 注册所有服务
 */
export function registerServices(): void {
    console.log('开始注册服务到依赖注入容器...');

    // ==================== 管理器服务 ====================
    
    // 用户管理器
    container.registerInstance(ServiceIdentifiers.USER_MANAGER, UserManager);
    
    // 邮件管理器
    container.registerInstance(ServiceIdentifiers.MAIL_MANAGER, MailManager);
    
    // 场景管理器
    container.registerInstance(ServiceIdentifiers.SCENE_MANAGER, SceneManager);
    
    // 组件管理器
    container.registerInstance(ServiceIdentifiers.COMPONENT_MANAGER, ComponentManage);
    
    // 客户端管理器
    container.registerInstance(ServiceIdentifiers.CLIENT_MANAGER, ClientManage);

    // ==================== 现代化服务 ====================
    
    // 背包服务
    container.registerSingleton(ServiceIdentifiers.BAG_SERVICE, () => new ModernBagService());
    
    // RPG服务
    container.registerSingleton(ServiceIdentifiers.RPG_SERVICE, () => new ModernRPGService());
    
    // 签到服务
    container.registerSingleton(ServiceIdentifiers.SIGN_SERVICE, () => new ModernSignService());
    
    // 意图服务
    container.registerSingleton(ServiceIdentifiers.INTENT_SERVICE, () => new ModernIntentService());

    // ==================== Repository层 ====================
    
    // 背包Repository（优先使用优化版本）
    container.registerSingleton(ServiceIdentifiers.BAG_REPOSITORY, () => {
        // 可以通过环境变量控制使用哪个版本
        const useOptimized = process.env.USE_OPTIMIZED_REPOSITORY !== 'false';
        return useOptimized ? new OptimizedBagRepository() : new BagRepository();
    });
    
    // RPG Repository（优先使用优化版本）
    container.registerSingleton(ServiceIdentifiers.RPG_REPOSITORY, () => {
        const useOptimized = process.env.USE_OPTIMIZED_REPOSITORY !== 'false';
        return useOptimized ? new OptimizedRPGRepository() : new RPGRepository();
    });

    // ==================== 工具服务 ====================
    
    // 通用工具
    container.registerInstance(ServiceIdentifiers.COMMON_TOOLS, common);
    
    // 卡片工具
    container.registerSingleton(ServiceIdentifiers.CARD_TOOLS, () => new Icard());
    
    // 数据库实例
    container.registerInstance(ServiceIdentifiers.DB_INSTANCE, dbInstance);

    // ==================== 缓存和辅助工具 ====================
    
    // 全局缓存
    container.registerInstance(ServiceIdentifiers.GLOBAL_CACHE, globalCache);
    
    // Repository辅助工具
    container.registerInstance(ServiceIdentifiers.REPOSITORY_HELPER, RepositoryHelper);

    console.log(`服务注册完成，共注册 ${container.size()} 个服务`);
    
    // 打印已注册的服务（调试用）
    if (process.env.NODE_ENV === 'development') {
        console.log('已注册的服务:', container.getRegisteredServices().map(s => s.toString()));
    }
}

/**
 * 服务健康检查
 * 验证关键服务是否正常工作
 */
export async function healthCheck(): Promise<{ success: boolean; issues: string[] }> {
    const issues: string[] = [];
    
    try {
        // 检查关键服务
        const criticalServices = [
            ServiceIdentifiers.USER_MANAGER,
            ServiceIdentifiers.BAG_SERVICE,
            ServiceIdentifiers.RPG_SERVICE,
            ServiceIdentifiers.COMMON_TOOLS
        ];
        
        for (const serviceId of criticalServices) {
            try {
                const service = await container.get(serviceId);
                if (!service) {
                    issues.push(`服务 ${serviceId.toString()} 获取失败`);
                }
            } catch (error) {
                issues.push(`服务 ${serviceId.toString()} 检查失败: ${error}`);
            }
        }
        
        // 检查缓存系统
        try {
            const cache = await container.get(ServiceIdentifiers.GLOBAL_CACHE);
            cache.set('health_check', true, 1000);
            const value = cache.get('health_check');
            if (!value) {
                issues.push('缓存系统工作异常');
            }
        } catch (error) {
            issues.push(`缓存系统检查失败: ${error}`);
        }
        
    } catch (error) {
        issues.push(`健康检查执行失败: ${error}`);
    }
    
    return {
        success: issues.length === 0,
        issues
    };
}

/**
 * 服务统计信息
 */
export function getServiceStats(): {
    totalServices: number;
    registeredServices: string[];
    containerInfo: {
        size: number;
        memoryUsage?: any;
    };
} {
    return {
        totalServices: container.size(),
        registeredServices: container.getRegisteredServices().map(s => s.toString()),
        containerInfo: {
            size: container.size(),
            // 可以添加更多统计信息
        }
    };
}

/**
 * 热重载服务配置
 * 在开发环境中重新注册服务
 */
export function reloadServices(): void {
    if (process.env.NODE_ENV !== 'development') {
        console.warn('服务热重载仅在开发环境中可用');
        return;
    }
    
    console.log('开始重新加载服务...');
    container.clear();
    registerServices();
    console.log('服务重新加载完成');
}

/**
 * 优雅关闭
 * 清理资源和连接
 */
export async function gracefulShutdown(): Promise<void> {
    console.log('开始优雅关闭服务...');
    
    try {
        // 清理缓存
        const cache = container.getSync(ServiceIdentifiers.GLOBAL_CACHE);
        if (cache && typeof cache.clear === 'function') {
            cache.clear();
        }
        
        // 关闭数据库连接（如果需要）
        const db = container.getSync(ServiceIdentifiers.DB_INSTANCE);
        if (db && typeof db.close === 'function') {
            await db.close();
        }
        
        // 清空容器
        container.clear();
        
        console.log('服务优雅关闭完成');
    } catch (error) {
        console.error('服务关闭时发生错误:', error);
    }
}

/**
 * 开发环境辅助工具
 */
export const DevTools = {
    /**
     * 列出所有已注册的服务
     */
    listServices(): void {
        console.log('=== 已注册的服务 ===');
        const services = container.getRegisteredServices();
        services.forEach((service, index) => {
            console.log(`${index + 1}. ${service.toString()}`);
        });
        console.log(`总计: ${services.length} 个服务`);
    },
    
    /**
     * 获取服务实例（调试用）
     */
    getService<T>(identifier: any): T {
        return container.getSync(identifier);
    },
    
    /**
     * 重新注册特定服务
     */
    reregisterService(identifier: any, factory: () => any): void {
        container.remove(identifier);
        container.registerSingleton(identifier, factory);
        console.log(`服务 ${identifier.toString()} 重新注册完成`);
    },
    
    /**
     * 服务依赖图（简单版本）
     */
    showDependencyGraph(): void {
        console.log('=== 服务依赖图 ===');
        // 这里可以实现更复杂的依赖分析
        console.log('暂未实现完整的依赖图分析');
    }
};

// 在开发环境中暴露调试工具
if (process.env.NODE_ENV === 'development') {
    (global as any).ServiceDevTools = DevTools;
}
